package org.nanotek.opencsv;

import java.rmi.server.UID;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;

import org.nanotek.base.GUIBase;

@SuppressWarnings("serial")
public class BaseMap implements GUIBase {

	private UID id; 
	private Map<String, String> innerMap;
	
	public BaseMap() 
	{ 
		this.innerMap = new HashMap<String,String>();
	}
	
	@Override
	public UID getId()
	{ 
		return this.id;
	}
	
	@Override
	public void setId(UID id) 
	{ 
		this.id = id; 
	}

	public boolean containsKey(Object key) {
		return innerMap.containsKey(key);
	}

	public boolean containsValue(Object value) {
		return innerMap.containsValue(value);
	}

	public String put(String key, String value) {
		return innerMap.put(key, value);
	}

	public String remove(Object key) {
		return innerMap.remove(key);
	}

	public void putAll(Map<? extends String, ? extends String> m) {
		innerMap.putAll(m);
	}

	public Set<String> keySet() {
		return innerMap.keySet();
	}

	public  void forEach(
			BiConsumer<? super String, ? super String> action) {
		innerMap.forEach(action);
	}

	public  void replaceAll(
			BiFunction<? super String, ? super String, ? extends String> function) {
		innerMap.replaceAll(function);
	}

	public  String putIfAbsent(String key, String value) {
		return innerMap.putIfAbsent(key, value);
	}

	public  boolean remove(Object key, Object value) {
		return innerMap.remove(key, value);
	}

	public  boolean replace(String key, String oldValue, String newValue) {
		return innerMap.replace(key, oldValue, newValue);
	}

	public  String replace(String key, String value) {
		return innerMap.replace(key, value);
	}

	public  String computeIfAbsent(String key,
			Function<? super String, ? extends String> mappingFunction) {
		return innerMap.computeIfAbsent(key, mappingFunction);
	}

	public  String computeIfPresent(
			String key,
			BiFunction<? super String, ? super String, ? extends String> remappingFunction) {
		return innerMap.computeIfPresent(key, remappingFunction);
	}

	public  String compute(
			String key,
			BiFunction<? super String, ? super String, ? extends String> remappingFunction) {
		return innerMap.compute(key, remappingFunction);
	}

	public  String merge(
			String key,
			String value,
			BiFunction<? super String, ? super String, ? extends String> remappingFunction) {
		return innerMap.merge(key, value, remappingFunction);
	}
}
